

/**
 * 
 * 
 * 
 * 
 * 
 *    
 * 


 //关于promise要解决回调地狱问题的说明：

         //需求：要封装一个方法 我给你要读取文件的路径，你这个方法能帮我读取文件，并把内容返回给我


 let p1 = Promise.resolve('我是成功的Promise');

p1.then(res => {
  return res + ',我又加了一段文字'
}).then(res => {
  console.log( res )  // 我是成功的Promise,我又加了一段文字
})

let p2 = Promise.reject('我是失败的Promise');
p2.catch(err => {
  throw new Error('我抛出了一个Error')
}).catch(err => {
  console.error(err)  // Error: 我抛出了一个Error
})



let p1 = Promise.resolve(1),
    p2 = Promise.resolve(22),
    p3 = Promise.resolve(333);

let loading = true; // 比方说加loading就可以加一个了 写个伪代码

Promise.all([p1,p2,p3]).then(res => {
  console.log(res) // [1, 22, 333]
  loading = false  //伪代码
})



then方法可以被同一个promise调用多次

then方法必须返回一个promise对象

当then传的值 不是一个函数的时候，就将值传递给下一个then，也叫做值穿透





eg:
               function buy(){
 3             console.log("开始买笔");
 4             var p = new Promise(function(resolve,reject){
 5                 setTimeout(function(){
 6                     console.log("买了笔芯");
 7                     resolve("数学作业");
 8                 },1000);
 9             });

10             return p;
11         }


12         //写作业
13         function work(data){

14             console.log("开始写作业："+data);

15             var p = new Promise(function(resolve,reject){
16                 setTimeout(function(){
17                     console.log("写完作业");
18                     resolve("作业本");
19                 },1000);
20             });

21             return p;

22  


23 
24         function out(data){
25             console.log("开始上交："+data);
26             var p = new Promise(function(resolve,reject){
27                 setTimeout(function(){
28                     console.log("上交完毕");
29                     resolve("得分：A");
30                 },1000);
31             });
32             return p;
33         }

34         /* 不建议使用这种方式
35         buy().then(function(data){
36             return work(data);
37         }).then(function(data){
38             return out(data);
39         }).then(function(data){
40             console.log(data);
41         });
42 
43         //推荐这种简化的写法
44         buy().then(work).then(out).then(function(data){
45             console.log(data);
46         });










function rework(data){
            console.log("开始写作业："+data);
            var p = new Promise(function(resolve,reject){
                setTimeout(function(){
                    console.log("写完作业");
                    resolve("作业本");   //data
                },1000);
            });
            return p;
        }
        
        rebuy().then(rework,function(data){
            console.log(data);
        });
        ---------> 相当于： rebuy().then(rework).catch( function(data){ 
                console.log(data)
        })


 

         （先看 vue-resource）

        function(result){
                console.log(result)
        }
--------------相当于：  result=>{ console.log(result.body) }
(result)=>{ console.log(result.body) }
         





                promise 基本的概念介绍：

                var promise =new Promise( function( resolve, reject){});   


               （表示一个异步操作） promise 上 有两个函数  resolve（成功之后的回调函数）   reject（失败之后的回调函数）

                在Promise prototype 属性上 有一个  .then（）  方法  
                
                成功的回调函数 把resolve 的结果 返回给调用者 
                .then( function(data){ console.log(data) }  )



              ＊＊＊＊＊形式上的 和 具体上的 Promise的异步操作：
         var promise =new Promise( function( resolve, reject){});  
                 ／／这里的promise只是形式上的异步操作

                eg:
                var promise =new Promise( function( resolve, reject){
                        fs.readFile()   //这里的promise 就表示一个读文件的异步操作
                }); 




                Promise实例只要被创建 就会立即执行里面的异步方法：
                
                分装成一个方法 当调用这个方法时 才会 执行promise的异步操作：

                function getFileByPath(fpath){
                        var promise =new Promise( function( resolve, reject){
                
                       fs.readFile(fpath,   'utf-8',
                        (err,dataStr)=>{
       
                        if(err)  return  errorCb(err)
                        succesCb(dataStr)
                        })

                        });
                }

                getFileByPath(./1.txt)      //调用函数




                通过 .then()    指定成功和失败的 回调函数
                function getFileByPath(fpath){
                        var promise =new Promise( function( resolve, reject){
                
                       fs.readFile(fpath,   'utf-8',
                        (err,dataStr)=>{
                        
                                if (err)    return reject(err)    //如果失败了 调用失败的函数
                                 resolve(dataStr) 
                        
                        } )

                        });
                        return promise
                }

getFileByPath(./1.txt).then(
         function(data){ console.log(data + '=====')}) ,
          function(err){ console.log(err.message)}) 
                           )     //调用函数


        *******  当promise 实例被创建  立即之行 .then()  




        分析promise 的执行步骤：



          打开promise的正确方法（使用promise解决异步回调地狱）：

          getFileByPath(./1.txt).then(
                          function(data){ console.log(data + '=====')}
                           return  getFileByPath(./2.txt)
                          ) ,
                          function(err){
                                  conole.log(err.message) 
                          //执行失败的回调函数之后 再 return 
                          return  getFileByPath(./2.txt)
                          }
                        
                                  ).then(
                          function(data){ console.log(data + '=====')}
                            return  getFileByPath(./3.txt)
                          ) 
                        
                                  ).then(
                          function(data){ console.log(data + '=====')}
                          
                          ) 
                                  ).then(
                                          function(data){
                                                  sonsole.log(data)
                                          }
                                  )


        

                //如果 前面的promise 执行失败 我们不想后面的promise 停止 可以 为每一个promise
                 指定一个失败的回调




                 如果第一个 promise 异常  不想  继续执行下面的 .then()   可以在最后加一个catch

                 eg:
                  getFileByPath(./1.txt).then(
                          function(data){ console.log(data + '=====')}
                           return  getFileByPath(./2.txt)
                          ) .then(
                          function(data){ console.log(data + '=====')}
                            return  getFileByPath(./3.txt)
                          ) .then(
                          function(data){ console.log(data + '=====')}
                           
                                  ).catch(
                                          function(err){
                                                  sonsole.log(err.message)
                                          }
                                  )







               ＊＊＊＊＊＊JQUERY 中ajax 使用 promise 指定成功回调函数：

                        





         
























 */


                    


        













 